HAL IRDA initialization and configuration functions migration

The goal of this page is to show how to migrate the initialization sequence using STM32CubeMX2:

  • Open STM32CubeMX2 IRDA configuration panel.

  • Configure the SW layer HAL.

  • Configure the IRDA main features.

  • Configure the advanced IRDA features if needed.

  • Configure the IRDA DMA(s) if the application requires the IRDA to be used in DMA mode.

  • Configure the NVIC if the application requires the IRDA to be used in IT mode.

  • Generate the code.

HAL IRDA configuration panel

Create a new project with STM32CubeMX2, start by enabling the UART instance as IrDA, as shown in this example with the selected UART4, then start the initialization and the main configuration.

Project configuration panel

HAL IRDA main features configuration

Configure the IRDA main features.

IRDA main feature configuration

HAL IRDA advanced features configuration

Configure the advanced IRDA features if needed.

IRDA advanced feature configuration

GPIO configuration

Configure GPIO pins.

IRDA GPIO configuration

DMA configuration

Configure the DMA for data reception as needed.

IRDA DMA configuration

NVIC configuration

Configure the NVIC in case of an interrupt.

IRDA NVIC configuration

Generated IRDA initialization and de-initialization sequences

The IRDA initialization sequence is generated in the mx_uart4_uart_init function in mx_uart4.c file under $YOUR_PROJECT_NAME$/$YOUR_PROJECT_NAME$_SW/generated/STM32Cube_CodeGen.

Related concepts:

STM32CubeMX2 Generated : IRDA initialization and De-initialization sequence

Topic

HAL1 Code Snippet

HAL2 Code Snippet

Handle declaration 

IRDA_HandleTypeDef hirda4;
DMA_HandleTypeDef handle_GPDMA1_Channel1;
DMA_HandleTypeDef handle_GPDMA1_Channel0;

hal_uart_handle_t hUART4;
hal_dma_handle_t hLPDMA1_CH1;
hal_dma_handle_t hLPDMA1_CH0;

Initialization and configuration sequence 

static void MX_UART4_IRDA_Init(void)
{

  hirda4.Instance = UART4;
  hirda4.Init.BaudRate = 115200;
  hirda4.Init.WordLength = IRDA_WORDLENGTH_8B;
  hirda4.Init.Parity = IRDA_PARITY_NONE;
  hirda4.Init.Mode = IRDA_MODE_TX_RX;
  hirda4.Init.Prescaler = 1;
  hirda4.Init.PowerMode = IRDA_POWERMODE_NORMAL;
  hirda4.Init.ClockPrescaler = IRDA_PRESCALER_DIV1;
  if (HAL_IRDA_Init(&hirda4) != HAL_OK)
  {
    Error_Handler();
  }

}



void HAL_IRDA_MspInit(IRDA_HandleTypeDef* hirda)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  if(hirda->Instance==UART4)
  {

    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_UART4;
    PeriphClkInit.Uart4ClockSelection = RCC_UART4CLKSOURCE_PCLK1;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
    {
      Error_Handler();
    }

    __HAL_RCC_UART4_CLK_ENABLE();

    __HAL_RCC_GPIOC_CLK_ENABLE();

    /**UART4 GPIO Configuration
    PC10     ------> UART4_TX
    PC11     ------> UART4_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF8_UART4;
    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

    /* UART4 DMA Init */
    /* GPDMA1_REQUEST_UART4_TX Init */
    handle_GPDMA1_Channel1.Instance = GPDMA1_Channel1;
    handle_GPDMA1_Channel1.Init.Request = GPDMA1_REQUEST_UART4_TX;
    handle_GPDMA1_Channel1.Init.BlkHWRequest = DMA_BREQ_SINGLE_BURST;
    handle_GPDMA1_Channel1.Init.Direction = DMA_MEMORY_TO_PERIPH;
    handle_GPDMA1_Channel1.Init.SrcInc = DMA_SINC_FIXED;
    handle_GPDMA1_Channel1.Init.DestInc = DMA_DINC_FIXED;
    handle_GPDMA1_Channel1.Init.SrcDataWidth = DMA_SRC_DATAWIDTH_BYTE;
    handle_GPDMA1_Channel1.Init.DestDataWidth = DMA_DEST_DATAWIDTH_BYTE;
    handle_GPDMA1_Channel1.Init.Priority = DMA_LOW_PRIORITY_LOW_WEIGHT;
    handle_GPDMA1_Channel1.Init.SrcBurstLength = 1;
    handle_GPDMA1_Channel1.Init.DestBurstLength = 1;
    handle_GPDMA1_Channel1.Init.TransferAllocatedPort = DMA_SRC_ALLOCATED_PORT0;
    handle_GPDMA1_Channel1.Init.TransferEventMode = DMA_TCEM_BLOCK_TRANSFER;
    handle_GPDMA1_Channel1.Init.Mode = DMA_NORMAL;
    if (HAL_DMA_Init(&handle_GPDMA1_Channel1) != HAL_OK)
    {
      Error_Handler();
    }




    HAL_NVIC_SetPriority(GPDMA1_Channel0_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(GPDMA1_Channel0_IRQn);







    __HAL_LINKDMA(hirda, hdmatx, handle_GPDMA1_Channel1);

    if (HAL_DMA_ConfigChannelAttributes(&handle_GPDMA1_Channel1,
                                        DMA_CHANNEL_NPRIV) != HAL_OK)
    {
      Error_Handler();
    }

    /* GPDMA1_REQUEST_UART4_RX Init */
    handle_GPDMA1_Channel0.Instance = GPDMA1_Channel0;
    handle_GPDMA1_Channel0.Init.Request = GPDMA1_REQUEST_UART4_RX;
    handle_GPDMA1_Channel0.Init.BlkHWRequest = DMA_BREQ_SINGLE_BURST;
    handle_GPDMA1_Channel0.Init.Direction = DMA_PERIPH_TO_MEMORY;
    handle_GPDMA1_Channel0.Init.SrcInc = DMA_SINC_FIXED;
    handle_GPDMA1_Channel0.Init.DestInc = DMA_DINC_FIXED;
    handle_GPDMA1_Channel0.Init.SrcDataWidth = DMA_SRC_DATAWIDTH_BYTE;
    handle_GPDMA1_Channel0.Init.DestDataWidth = DMA_DEST_DATAWIDTH_BYTE;
    handle_GPDMA1_Channel0.Init.Priority = DMA_LOW_PRIORITY_LOW_WEIGHT;
    handle_GPDMA1_Channel0.Init.SrcBurstLength = 1;
    handle_GPDMA1_Channel0.Init.DestBurstLength = 1;
    handle_GPDMA1_Channel0.Init.TransferAllocatedPort = DMA_SRC_ALLOCATED_PORT0;
    handle_GPDMA1_Channel0.Init.TransferEventMode = DMA_TCEM_BLOCK_TRANSFER;
    handle_GPDMA1_Channel0.Init.Mode = DMA_NORMAL;
    if (HAL_DMA_Init(&handle_GPDMA1_Channel0) != HAL_OK)
    {
      Error_Handler();
    }

    HAL_NVIC_SetPriority(GPDMA1_Channel1_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(GPDMA1_Channel1_IRQn);





    __HAL_LINKDMA(hirda, hdmarx, handle_GPDMA1_Channel0);

    if (HAL_DMA_ConfigChannelAttributes(&handle_GPDMA1_Channel0,
                                         DMA_CHANNEL_NPRIV) != HAL_OK)
    {
      Error_Handler();
    }
    /* UART4 interrupt Init */
    HAL_NVIC_SetPriority(UART4_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(UART4_IRQn);

  }
}

hal_uart_handle_t *mx_uart4_uart_init(void)
{
  hal_uart_irda_config_t irda_config;

  irda_config.baud_rate = 115200;
  irda_config.clock_prescaler = HAL_UART_PRESCALER_DIV1;
  irda_config.word_length = HAL_UART_WORD_LENGTH_8_BIT;
  irda_config.irda_power_mode = HAL_UART_IRDA_POWER_MODE_NORMAL;
  irda_config.direction = HAL_UART_DIRECTION_TX_RX;
  irda_config.irda_prescaler = 1;
  irda_config.parity = HAL_UART_PARITY_NONE;
  irda_config.one_bit_sampling = HAL_UART_ONE_BIT_SAMPLE_ENABLE;

  /* Basic configuration */
  if (HAL_UART_Init(&hUART4, HAL_UART4) != HAL_OK)
  {
    return NULL;
  }

  if (HAL_UART_IRDA_SetConfig(&hUART4, &irda_config) != HAL_OK)
  {
    return NULL;
  }

  HAL_RCC_UART4_EnableClock();
  if (HAL_RCC_UART4_SetKernelClkSource(HAL_RCC_UART4_CLK_SRC_PCLK1) != HAL_OK)
  {
    return NULL;
  }

  HAL_RCC_GPIOA_EnableClock();

  hal_gpio_config_t  gpio_config;

  /**
    UART4 GPIO Configuration

    [GPIO Pin] ------> [Signal Name]

       PA1     ------>   UART4_RX
       PA0     ------>   UART4_TX
    **/
  gpio_config.mode        = HAL_GPIO_MODE_ALTERNATE;
  gpio_config.output_type = HAL_GPIO_OUTPUT_PUSHPULL;
  gpio_config.pull        = HAL_GPIO_PULL_NO;
  gpio_config.speed       = HAL_GPIO_SPEED_FREQ_LOW;
  gpio_config.alternate   = HAL_GPIO_AF_8;
  HAL_GPIO_Init(HAL_GPIOA, HAL_GPIO_PIN_1 | HAL_GPIO_PIN_0, &gpio_config);




  /* Configure the DMA TX */
  if (HAL_DMA_Init(&hLPDMA1_CH1, HAL_LPDMA1_CH1) != HAL_OK)
  {
    return NULL;
  }

  HAL_RCC_LPDMA1_EnableClock();

  hal_dma_direct_xfer_config_t xfer_cfg_uart4_tx_dma;
  xfer_cfg_uart4_tx_dma.request         = HAL_LPDMA1_REQUEST_UART4_TX;
  xfer_cfg_uart4_tx_dma.direction       = HAL_DMA_DIRECTION_MEMORY_TO_PERIPH;
  xfer_cfg_uart4_tx_dma.src_inc         = HAL_DMA_SRC_ADDR_INCREMENTED;
  xfer_cfg_uart4_tx_dma.dest_inc        = HAL_DMA_DEST_ADDR_FIXED;
  xfer_cfg_uart4_tx_dma.src_data_width  = HAL_DMA_SRC_DATA_WIDTH_BYTE;
  xfer_cfg_uart4_tx_dma.dest_data_width = HAL_DMA_DEST_DATA_WIDTH_BYTE;
  xfer_cfg_uart4_tx_dma.priority        = HAL_DMA_PRIORITY_LOW_WEIGHT_LOW;

  if (HAL_DMA_SetConfigPeriphDirectXfer(&hLPDMA1_CH1,
                                        &xfer_cfg_uart4_tx_dma) != HAL_OK)
  {
    return NULL;
  }

  /* Enable the interruption for LPDMA1_CH1 */
  HAL_CORTEX_NVIC_SetPriority(LPDMA1_CH1_IRQn,
                              HAL_CORTEX_NVIC_PREEMP_PRIORITY_0,
                              HAL_CORTEX_NVIC_SUB_PRIORITY_0);
  HAL_CORTEX_NVIC_EnableIRQ(LPDMA1_CH1_IRQn);

  /* Link the Transmit DMA handle to the UART handle */
  if (HAL_UART_SetTxDMA(&hUART4, &hLPDMA1_CH1) != HAL_OK)
  {
    return NULL;
  }

  /* Configure the DMA RX */
  if (HAL_DMA_Init(&hLPDMA1_CH0, HAL_LPDMA1_CH0) != HAL_OK)
  {
    return NULL;
  }

  HAL_RCC_LPDMA1_EnableClock();

  hal_dma_direct_xfer_config_t xfer_cfg_uart4_rx_dma;
  xfer_cfg_uart4_rx_dma.request         = HAL_LPDMA1_REQUEST_UART4_RX;
  xfer_cfg_uart4_rx_dma.direction       = HAL_DMA_DIRECTION_PERIPH_TO_MEMORY;
  xfer_cfg_uart4_rx_dma.src_inc         = HAL_DMA_SRC_ADDR_FIXED;
  xfer_cfg_uart4_rx_dma.dest_inc        = HAL_DMA_DEST_ADDR_INCREMENTED;
  xfer_cfg_uart4_rx_dma.src_data_width  = HAL_DMA_SRC_DATA_WIDTH_BYTE;
  xfer_cfg_uart4_rx_dma.dest_data_width = HAL_DMA_DEST_DATA_WIDTH_BYTE;
  xfer_cfg_uart4_rx_dma.priority        = HAL_DMA_PRIORITY_LOW_WEIGHT_LOW;

  if (HAL_DMA_SetConfigPeriphDirectXfer(&hLPDMA1_CH0,
                                        &xfer_cfg_uart4_rx_dma) != HAL_OK)
  {
    return NULL;
  }

  /* Enable the interruption for LPDMA1_CH0 */
  HAL_CORTEX_NVIC_SetPriority(LPDMA1_CH0_IRQn,
                              HAL_CORTEX_NVIC_PREEMP_PRIORITY_0,
                              HAL_CORTEX_NVIC_SUB_PRIORITY_0);
  HAL_CORTEX_NVIC_EnableIRQ(LPDMA1_CH0_IRQn);

  /* Link the Receive DMA handle to the UART handle */
  if (HAL_UART_SetRxDMA(&hUART4, &hLPDMA1_CH0) != HAL_OK)
  {
    return NULL;
  }

  /* Enable interrupt */
  HAL_CORTEX_NVIC_SetPriority(UART4_IRQn,
                              HAL_CORTEX_NVIC_PREEMP_PRIORITY_0,
                              HAL_CORTEX_NVIC_SUB_PRIORITY_0);
  HAL_CORTEX_NVIC_EnableIRQ(UART4_IRQn);

  return &hUART4;
}

Deinitialization sequence 

void HAL_IRDA_MspDeInit(IRDA_HandleTypeDef* hirda)
{
  if(hirda->Instance==UART4)
  {

    /* Peripheral clock disable */
    __HAL_RCC_UART4_CLK_DISABLE();

    HAL_GPIO_DeInit(GPIOC, GPIO_PIN_10|GPIO_PIN_11);

    /* UART4 DMA DeInit */
    HAL_DMA_DeInit(hirda->hdmatx);
    HAL_DMA_DeInit(hirda->hdmarx);

    /* UART4 interrupt DeInit */
    HAL_NVIC_DisableIRQ(UART4_IRQn);
  }

}

void mx_uart4_uart_deinit(void)
{
  /* Disable interrupt */
  HAL_CORTEX_NVIC_DisableIRQ(LPDMA1_CH0_IRQn);
  (void)HAL_UART_DeInit(&hUART4);

  HAL_RCC_UART4_Reset();

  HAL_RCC_UART4_DisableClock();

  /* De-initialize all GPIO pins associated with UART4 */
  HAL_GPIO_DeInit(HAL_GPIOA, HAL_GPIO_PIN_0 | HAL_GPIO_PIN_1);

  /* De-initialize the DMA channel */
  HAL_DMA_DeInit(&hLPDMA1_CH1);

  /* Disable the interruption for DMA */
  HAL_CORTEX_NVIC_DisableIRQ(LPDMA1_CH1_IRQn);

  /* De-initialize the DMA channel */
  HAL_DMA_DeInit(&hLPDMA1_CH0);

  /* Disable the interruption for DMA */
  HAL_CORTEX_NVIC_DisableIRQ(LPDMA1_CH0_IRQn);
}

IRQ handle function 

void GPDMA1_Channel0_IRQHandler(void)
{
  HAL_DMA_IRQHandler(&handle_GPDMA1_Channel0);
}

void GPDMA1_Channel1_IRQHandler(void)
{
  HAL_DMA_IRQHandler(&handle_GPDMA1_Channel1);
}

void UART4_IRQHandler(void)
{
  HAL_IRDA_IRQHandler(&hirda4);
}

void LPDMA1_CH0_IRQHandler(void)
{
  HAL_DMA_IRQHandler(&hLPDMA1_CH0);
}

void LPDMA1_CH1_IRQHandler(void)
{
  HAL_DMA_IRQHandler(&hLPDMA1_CH1);
}

void UART4_IRQHandler(void)
{
  HAL_UART_IRQHandler(&hUART4);
}